home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / FireMan.swf / scripts / frame_1179 / PlaceObject2_276_1146 / CLIPACTIONRECORD onClipEvent(enterFrame).as next >
Text File  |  2008-09-12  |  14KB  |  574 lines
  1. onClipEvent(enterFrame){
  2.    function hitPlatforms()
  3.    {
  4.       var u;
  5.       u = suelo = sueloI = sueloD = false;
  6.       i = -9;
  7.       while(i <= 0)
  8.       {
  9.          sueloI = sueloI || mapa.hitTest(_X + i,_Y,true);
  10.          i++;
  11.       }
  12.       i = 1;
  13.       while(i <= 9)
  14.       {
  15.          sueloD = sueloD || mapa.hitTest(_X + i,_Y,true);
  16.          i++;
  17.       }
  18.       if(sueloI && wallizq() && !sueloD && !techo)
  19.       {
  20.          return undefined;
  21.       }
  22.       if(sueloD && wallder() && !sueloI && !techo)
  23.       {
  24.          return undefined;
  25.       }
  26.       suelo = sueloI || sueloD;
  27.       if(suelo)
  28.       {
  29.          falling = false;
  30.          currenthigh = 0;
  31.          techo = false;
  32.          if(s)
  33.          {
  34.             landing.start();
  35.             s = false;
  36.          }
  37.          j = -15;
  38.          while(j <= 15)
  39.          {
  40.             i = -9;
  41.             while(i <= 9)
  42.             {
  43.                if(mapa.hitTest(_X + i,_Y + j,true) && !mapa.hitTest(_X + i,_Y + j - 1,true))
  44.                {
  45.                   u = true;
  46.                   break;
  47.                }
  48.                i++;
  49.             }
  50.             if(u)
  51.             {
  52.                break;
  53.             }
  54.             j++;
  55.          }
  56.          _Y = _Y + j;
  57.          j = vertical = 0;
  58.       }
  59.       return undefined;
  60.    }
  61.    function roof()
  62.    {
  63.       var u = techo = false;
  64.       i = -3;
  65.       while(i <= 3)
  66.       {
  67.          if(mapa.hitTest(_X + i,_Y - 30,true))
  68.          {
  69.             u = techo = true;
  70.             break;
  71.          }
  72.          i++;
  73.       }
  74.       return u;
  75.    }
  76.    function gridx(a)
  77.    {
  78.       return int(a / GRIDSIZE);
  79.    }
  80.    function gridy(b)
  81.    {
  82.       if(b >= 0)
  83.       {
  84.          return int(b / GRIDSIZE);
  85.       }
  86.       return Math.floor(b / GRIDSIZE);
  87.    }
  88.    function render()
  89.    {
  90.       if(!death)
  91.       {
  92.          scrollspeed = 0;
  93.          if(this.hitTest(_root.scrollmask))
  94.          {
  95.             doscroll = true;
  96.          }
  97.          if(_root.topeizq._x >= 0 && horizontal < 0 || _root.topeder._x <= 256 && horizontal > 0)
  98.          {
  99.             doscroll = false;
  100.          }
  101.          if(doscroll)
  102.          {
  103.             _X = lastX;
  104.             scrollspeed = setSpeed() + _root.windx;
  105.          }
  106.          lastX = _X;
  107.          lastY = _Y;
  108.          if(timerdamage == 0 && hitted && !invisible)
  109.          {
  110.             timerdamage = FLASHTIME;
  111.             timerinvisible = INVISIBLETIME;
  112.             keys = false;
  113.             _root.currentdamage += DAMAGE;
  114.             barra.gotoAndStop(_root.currentdamage + 1);
  115.             _parent.fhitted.start();
  116.             if(rising || jumping)
  117.             {
  118.                vertical = 0.5;
  119.                falling = true;
  120.             }
  121.          }
  122.          if(timerdamage > 0)
  123.          {
  124.             flashing = true;
  125.             timerdamage--;
  126.             if(_xscale < 0 && !wallder())
  127.             {
  128.                if(doscroll)
  129.                {
  130.                   scrollspeed = hforce / 2;
  131.                }
  132.                else
  133.                {
  134.                   horizontal = hforce / 2;
  135.                }
  136.             }
  137.             if(_xscale > 0 && !wallizq())
  138.             {
  139.                if(doscroll)
  140.                {
  141.                   scrollspeed = hforce / 2 * -1;
  142.                }
  143.                else
  144.                {
  145.                   horizontal = hforce / 2 * -1;
  146.                }
  147.             }
  148.          }
  149.          if(flashing && timerdamage == 0)
  150.          {
  151.             flashing = false;
  152.             keys = true;
  153.             timerinvisible = INVISIBLETIME;
  154.             invisible = true;
  155.          }
  156.          if(invisible)
  157.          {
  158.             timerinvisible--;
  159.             timerinvisible % 2 != 0 ? (_visible = false) : (_visible = true);
  160.          }
  161.          if(timerinvisible <= 0 && invisible)
  162.          {
  163.             invisible = false;
  164.             hitted = false;
  165.             _visible = true;
  166.          }
  167.          if(_root.currentdamage + 1 >= MAXDAMAGE)
  168.          {
  169.             death = true;
  170.             barra.gotoAndStop(MAXDAMAGE);
  171.             _root.fdeath.start();
  172.          }
  173.          DAMAGE = 0;
  174.          if(!shooting && abletoshoot)
  175.          {
  176.             if(Key.isDown(SHOOT) && keys)
  177.             {
  178.                justshoot = true;
  179.                abletoshoot = false;
  180.             }
  181.             else
  182.             {
  183.                justshoot = false;
  184.             }
  185.          }
  186.          if(justshoot && !shooting)
  187.          {
  188.             if(_xscale > 0)
  189.             {
  190.                shoot1._x = _X + 41;
  191.             }
  192.             else
  193.             {
  194.                shoot1._x = _X - 41;
  195.             }
  196.             if(!vertical)
  197.             {
  198.                shoot1._y = _Y - 14;
  199.             }
  200.             else
  201.             {
  202.                shoot1._y = _Y - 20;
  203.             }
  204.             shoot1._visible = true;
  205.             if(_xscale > 0)
  206.             {
  207.                shoot1.dx = Math.abs(shoot1.dx);
  208.                shoot1._xscale = Math.abs(shoot1._xscale);
  209.             }
  210.             if(_xscale < 0)
  211.             {
  212.                shoot1.dx = Math.abs(shoot1.dx) * -1;
  213.                shoot1._xscale = Math.abs(shoot1._xscale) * -1;
  214.             }
  215.             blast.start();
  216.             shooting = true;
  217.             justshoot = false;
  218.          }
  219.          if(!shooting && !abletoshoot)
  220.          {
  221.             if(!Key.isDown(SHOOT))
  222.             {
  223.                abletoshoot = true;
  224.             }
  225.          }
  226.          x = setSpeed();
  227.          if(!flashing)
  228.          {
  229.             horizontal = x;
  230.          }
  231.          if(vertical == 0 && Key.isDown(ARRIBA) && upreleased && keys)
  232.          {
  233.             vertical = vforce * -1;
  234.             horizontal += platform.dx;
  235.             platformscroll = 0;
  236.             rising = true;
  237.             upreleased = false;
  238.             salto.start();
  239.          }
  240.          if(!falling && !uprelease)
  241.          {
  242.             if(!Key.isDown(ARRIBA))
  243.             {
  244.                upreleased = true;
  245.             }
  246.          }
  247.          if(rising)
  248.          {
  249.             if(roof())
  250.             {
  251.                falling = true;
  252.                startfall = true;
  253.                rising = false;
  254.             }
  255.             if(currenthigh < MAXJUMP && Key.isDown(ARRIBA) && !upreleased && !flashing)
  256.             {
  257.                if(roof())
  258.                {
  259.                   startfall = true;
  260.                   falling = true;
  261.                   rising = false;
  262.                }
  263.                if(currenthigh < vforcei)
  264.                {
  265.                   vertical = - Math.abs(vforcei);
  266.                }
  267.                else
  268.                {
  269.                   vertical = - Math.abs(vforce);
  270.                }
  271.                currenthigh += Math.abs(vertical);
  272.             }
  273.             else
  274.             {
  275.                vertical *= gravity;
  276.                currenthigh += Math.abs(vertical);
  277.                if(Math.abs(vertical) < 1)
  278.                {
  279.                   startfall = true;
  280.                   falling = true;
  281.                   rising = false;
  282.                }
  283.             }
  284.          }
  285.          if(Key.isDown(SLIDEKEY) && !rising && !falling && keys && slidereleased)
  286.          {
  287.             if(_xscale < 0 && !wallizq())
  288.             {
  289.                slideLeft = true;
  290.                slideRight = false;
  291.             }
  292.             if(_xscale > 0 && !wallder())
  293.             {
  294.                slideLeft = false;
  295.                slideRight = true;
  296.             }
  297.             slide = slideLeft || slideRight;
  298.             slidereleased = false;
  299.          }
  300.          if(slide && slidetimer == 0)
  301.          {
  302.             slidetimer = SLIDETIME;
  303.          }
  304.          if(slide && slidetimer > 0)
  305.          {
  306.             slidetimer--;
  307.             if(slidetimer == 0 || Key.isDown(IZQ) && slideRight || Key.isDown(DER) && slideLeft || falling || wallizq() && slideLeft || wallder() && slideRight)
  308.             {
  309.                slide = slideLeft = slideRight = slidetimer = 0;
  310.             }
  311.          }
  312.          if(!Key.isDown(SLIDEKEY) && !slidereleased)
  313.          {
  314.             slidereleased = true;
  315.          }
  316.          if(falling)
  317.          {
  318.             s = true;
  319.             if(startfall)
  320.             {
  321.                vertical = Math.abs(vforcei / 2) * accel;
  322.                startfall = false;
  323.             }
  324.             else
  325.             {
  326.                vertical = Math.abs(vertical) * accel;
  327.             }
  328.             if(vertical > MAXVERTICAL)
  329.             {
  330.                vertical = MAXVERTICAL;
  331.             }
  332.             platformscroll = 0;
  333.             hitPlatforms();
  334.             if(_Y >= 245)
  335.             {
  336.                death = true;
  337.                _root.fdeath.start();
  338.             }
  339.          }
  340.          if(tornado)
  341.          {
  342.             floating = true;
  343.             playtornado = true;
  344.             vertical2 += vforce;
  345.             if(vertical2 > MAXVERTICAL)
  346.             {
  347.                vertical2 = MAXVERTICAL / 6;
  348.             }
  349.          }
  350.          else
  351.          {
  352.             playtornado = false;
  353.          }
  354.          if(floating)
  355.          {
  356.             if(tornado)
  357.             {
  358.                vertical = - vertical2;
  359.             }
  360.             else
  361.             {
  362.                vertical = -4;
  363.                floating = false;
  364.                falling = false;
  365.                rising = true;
  366.                startfall = true;
  367.                vertical2 = 0;
  368.             }
  369.          }
  370.          if(playtornado && !soundtrigged)
  371.          {
  372.             _root.wind04.setVolume(100);
  373.             _root.wind04.start();
  374.             u = 100;
  375.             soundtrigged = true;
  376.          }
  377.          if(soundtrigged && !playtornado && u > 0)
  378.          {
  379.             u -= 5;
  380.             _root.wind04.setVolume(u);
  381.             if(u == 0)
  382.             {
  383.                _root.wind04.stop();
  384.                playtornado = true;
  385.                soundtrigged = false;
  386.             }
  387.          }
  388.          tornado = false;
  389.          if(_root.windx)
  390.          {
  391.             horizontal += _root.windx;
  392.          }
  393.          _Y = _Y + vertical + platform.dy;
  394.          if(horizontal < 0 && !wallizq() || horizontal > 0 && !wallder())
  395.          {
  396.             _X = _X + horizontal;
  397.          }
  398.          drawframe();
  399.          x1 = LastX - platform._x;
  400.          x2 = _X - platform._x;
  401.          if(!falling && !rising)
  402.          {
  403.             hitPlatforms();
  404.             if(!suelo)
  405.             {
  406.                vertical = 2;
  407.                falling = true;
  408.             }
  409.          }
  410.       }
  411.       else
  412.       {
  413.          drawframe();
  414.          vertical = horizontal = doscroll = scrollspeed = 0;
  415.          if(!f)
  416.          {
  417.             _root.fade.begin = true;
  418.             f = true;
  419.          }
  420.       }
  421.    }
  422.    function wallizq()
  423.    {
  424.       var u = false;
  425.       var t = !slide ? 12 : 20;
  426.       i = -24;
  427.       while(i < -15)
  428.       {
  429.          if(mapa.hitTest(_X - t,_Y + i,true))
  430.          {
  431.             u = true;
  432.             break;
  433.          }
  434.          i++;
  435.       }
  436.       return u;
  437.    }
  438.    function wallder()
  439.    {
  440.       var u = false;
  441.       var t = !slide ? 12 : 20;
  442.       i = -24;
  443.       while(i < -15)
  444.       {
  445.          if(mapa.hitTest(_X + t,_Y + i,true))
  446.          {
  447.             u = true;
  448.             break;
  449.          }
  450.          i++;
  451.       }
  452.       return u;
  453.    }
  454.    function setSpeed()
  455.    {
  456.       if(slideLeft && !rising)
  457.       {
  458.          forward = true;
  459.          backward = false;
  460.          if(horizontal == 0)
  461.          {
  462.             return hforce * -1;
  463.          }
  464.          return hforce * -1.5;
  465.       }
  466.       if(slideRight && !rising)
  467.       {
  468.          forward = false;
  469.          backward = true;
  470.          if(horizontal == 0)
  471.          {
  472.             return hforce;
  473.          }
  474.          return hforce * 1.5;
  475.       }
  476.       if(Key.isDown(DER) && keys && !wallder())
  477.       {
  478.          forward = false;
  479.          backward = true;
  480.          if(horizontal == 0)
  481.          {
  482.             return hforcei;
  483.          }
  484.          return hforce;
  485.       }
  486.       if(Key.isDown(IZQ) && keys && !wallizq())
  487.       {
  488.          forward = true;
  489.          backward = false;
  490.          if(horizontal == 0)
  491.          {
  492.             return hforcei * -1;
  493.          }
  494.          return hforce * -1;
  495.       }
  496.       return 0;
  497.    }
  498.    function drawFrame()
  499.    {
  500.       if(victory)
  501.       {
  502.          this.gotoAndStop("victory");
  503.          return undefined;
  504.       }
  505.       if(death)
  506.       {
  507.          this.gotoAndStop("death");
  508.          return undefined;
  509.       }
  510.       if(flashing)
  511.       {
  512.          this.gotoAndStop("hitted");
  513.          return undefined;
  514.       }
  515.       if(lastX != _X)
  516.       {
  517.          !forward ? (_xscale = Math.abs(_xscale)) : (_xscale = Math.abs(_xscale) * -1);
  518.       }
  519.       if(!shooting)
  520.       {
  521.          if(lastY > _Y && rising)
  522.          {
  523.             this.gotoAndStop("jump");
  524.             _root.estado = 3;
  525.             return undefined;
  526.          }
  527.       }
  528.       else if(lastY > _Y && rising)
  529.       {
  530.          this.gotoAndStop("attackJ");
  531.          _root.estado = 4;
  532.          return undefined;
  533.       }
  534.       if(lastY < _Y && falling || floating)
  535.       {
  536.          this.gotoAndStop("fall");
  537.          _root.estado = 5;
  538.          return undefined;
  539.       }
  540.       if(slide)
  541.       {
  542.          this.gotoAndStop("slide");
  543.          _root.estado = 6;
  544.          return undefined;
  545.       }
  546.       if(shooting)
  547.       {
  548.          if(horizontal != _root.windx)
  549.          {
  550.             this.gotoAndStop("attackRU");
  551.             sprite.gotoAndPlay(frame);
  552.             _root.estado = 2;
  553.             return undefined;
  554.          }
  555.       }
  556.       else if(horizontal != _root.windx)
  557.       {
  558.          this.gotoAndStop("run");
  559.          _root.estado = 1;
  560.          return undefined;
  561.       }
  562.       if(shooting)
  563.       {
  564.          this.gotoAndStop("attackST");
  565.       }
  566.       else
  567.       {
  568.          this.gotoAndStop("standing");
  569.       }
  570.    }
  571.    render();
  572.    frame = sprite._currentframe;
  573. }
  574.